#pragma once

#ifndef TABLAHASHA_CPP
#define TABLAHASHA_CPP

#include "TablaHash.h"
#include "Cadena.h"
#include "ComparadorCadena.h"
#include "ComparadorTuplaClave.h"
#include "TablaHashA.h"
#include "ComparadorClave.h"

 

 
template <class C, class V>
TablaHashA<C,V>::TablaHashA(const Puntero<Comparador<C>> comparador, Puntero<FuncionHash<C>> funcionHash, int largo)//:tabla(new ComparadorTuplaClave<C,V>(comparador))
{ 
		this->tabla = new TablaHash<C,V>(comparador,funcionHash,largo);
}


//TODO AGREGAR ITERADOR
template <class C, class V>
TablaHashA<C,V>::TablaHashA(Iterador<Tupla<C,V>>  iterador, const Puntero<Comparador<C>> comparador, Puntero<FuncionHash<C>> funcionHash, int largo)//:tabla(new ComparadorTuplaClave<C,V>(comparador))
{
 	this->tabla= new TablaHash<C,V>(new ComparadorTuplaClave<C,V>(comparador),funcionHash,largo);
	for (Iterador<T> it =  ObtenerIterador();it.HayElemento() ;it++)
	{
		Agregar(it.ElementoActual());
	}
	
}


 

template <class C, class V>
bool TablaHashA<C,V>::Agregar(const C& c, const V& v)
{
	if(!tabla->EstaDefinido(c))
	{
	tabla->Insertar(c,v);
	return true;
	}
	else
		return false;
	
	 
}



/* retorna true SII encuentra un elemento con la clave a borrar */
template <class C, class V>
bool TablaHashA<C,V>::Borrar(const C& c)
{
 	
	if(tabla->EstaDefinido(c))
	{
	 	tabla->Borrar(c);
		return true;
	}
	return false;
	}

template <class C, class V>
void TablaHashA<C,V>::BorrarTodos()
{
	 tabla->BorrarTodos();
}

template <class C, class V>
Puntero<Tabla<C,V>> TablaHashA<C,V>::Clonar() const
{
	 
	return NULL;
}

/* PREDICADOS */
template <class C, class V>
bool TablaHashA<C,V>::EstaVacia() const
{
	 return this->tabla->EstaVacia();
}

template <class C, class V>
bool TablaHashA<C,V>::EstaLlena() const
{
	return this->tabla->EstaLlena();
}

template <class C, class V>
bool TablaHashA<C,V>::Pertenece(const C& c) const
{

	return tabla->EstaDefinido(c);
   }

/* SELECTORAS */
template <class C, class V>
const V& TablaHashA<C,V>::Obtener(const C& c) const
{
	return tabla->Recuperar(c); 
}

template <class C, class V>
bool TablaHashA<C,V>::IntentarObtener(const C& c, V& v) const
{ 
	 return tabla->Recuperar(c,v);
}

template <class C, class V>
nat TablaHashA<C,V>::Largo() const
{
	return tabla->Tamanio();
}
template <class C, class V>
Iterador<C> TablaHashA<C,V>::Claves() const
{

	return tabla->Claves();

}

template <class C, class V>
Iterador<V> TablaHashA<C,V>::Valores() const
{
	return tabla->Valores();
}

template <class C, class V>
Iterador<Tupla<C,V>> TablaHashA<C,V>::ObtenerIterador() const
{
	 return NULL;
}

//template <class C, class V>
//void TablaAvl<c,v>::imprimir(pnodoavl avl ) const
//{
//	if (avl){
//		cout<<"(";
//		imprimir(avl->izq);
//		cout << ")";
//		cout << avl-> dato.Dato1 << "-"<< avl->fb;
//		cout<< " (";
//		imprimir(avl->der);
//		cout<< ")"; 
//	}

#endif